package com.hatricks.is.gld.work.ai;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.ArrayList;
import java.util.List;

public class LLMUtils {

    public static String getJSONString(String text) {
        if (text == null) {
            return "";
        }
        text = text.replaceAll("\n", "");

        if (text.contains("```json")) {
            return extractAndParseJson(text);
        } else if (text.contains("```") && text.lastIndexOf("```") > text.indexOf("```")) {
            text = text.substring(text.indexOf("```") + 3, text.lastIndexOf("```"));
        } else if (text.contains("{")) {
            return extractAndParseJson2(text);
        }
        return text;
    }

    /**
     * 提取并解析 JSON 内容   标识符为： ```json  ```
     * @param text 输入的字符串
     * @return 解析后的 JSON 字符串
     */
    private static String extractAndParseJson(String text) {
        if (text == null || text.isEmpty()) {
            return ""; // 空输入直接返回空字符串
        }

        int start = text.indexOf("```json") + 7; // 跳过 "```json"
        int end = text.indexOf("```", start);    // 找到第一个 ``` 的位置
        if (end <= start) {
            return ""; // 如果未找到有效内容，返回空字符串
        }

        String extractedContent = text.substring(start, end).trim();

        try {
            // 尝试直接解析为 JSON 数组
            JSONArray jsonArray = JSON.parseArray(extractedContent);
            return formatJson(jsonArray);
        } catch (Exception e) {
            // 忽略异常，继续尝试其他解析方式
        }

        if (extractedContent.contains("},{")) {
            // 检查是否包含多个 JSON 对象
            return handleMultipleJsonObjects(extractedContent);
        }

        try {
            // 尝试解析为单个 JSON 对象
            JSONObject jsonObject = JSON.parseObject(extractedContent);
            return formatJson(jsonObject);
        } catch (Exception e) {
            // 忽略异常，继续兜底逻辑
        }

        return "";
    }

    /**
     * 处理多个独立的 JSON 对象
     * @param content 输入的字符串
     * @return 格式化的 JSON 数组字符串
     */
    private static String handleMultipleJsonObjects(String content) {
        JSONArray jsonArray = new JSONArray();
        String[] jsonObjects = content.split("\\},\\{");
        for (String jsonObjectStr : jsonObjects) {
            try {
                // 修复可能缺失的大括号
                if (!jsonObjectStr.startsWith("{")) {
                    jsonObjectStr = "{" + jsonObjectStr;
                }
                if (!jsonObjectStr.endsWith("}")) {
                    jsonObjectStr += "}";
                }
                JSONObject jsonObject = JSON.parseObject(jsonObjectStr);
                jsonArray.add(jsonObject);
            } catch (Exception e) {
                // 记录无效的 JSON 内容
                System.err.println("无效的 JSON 内容: " + jsonObjectStr);
            }
        }
        return formatJson(jsonArray);
    }

    /**
     * 格式化 JSON 输出
     * @param object JSON 对象或数组
     * @return 格式化的 JSON 字符串
     */
    private static String formatJson(Object object) {
        return JSON.toJSONString(object, true); // 使用 fastjson 格式化输出
    }

    /**
     * 提取并解析 JSON 内容   标识符为：{ }
     * @param text 输入的字符串
     * @return 解析后的 JSON 字符串
     */
    private static String extractAndParseJson2(String text) {
        if (text == null || text.isEmpty()) {
            return ""; // 空输入直接返回空字符串
        }

        int start = text.indexOf("{");
        int end = text.indexOf("}", start);    // 找到第一个 } 的位置
        if (end <= start) {
            return ""; // 如果未找到有效内容，返回空字符串
        }
        String extractedContent = text.substring(start, end + 1).trim();
        try {
            // 尝试解析为 JSON 对象
            JSONObject jsonObject = JSON.parseObject(extractedContent);
            return formatJson(jsonObject);
        } catch (Exception e) {
            // 忽略异常，继续兜底逻辑
        }
        return "";
    }

    public static Boolean isJSONString(String text) {
        if (text == null || text.isEmpty() || "null".equals(text)) {
            return false;
        }
        if (!JSON.isValid(text)) {
            return false;
        }
        text = text.replaceAll("\n", "");
        text = text.trim();
        if (text.startsWith("{") && text.endsWith("}")) {
            return true;
        }
        if (text.startsWith("[") && text.endsWith("]")) {
            return true;
        }
        return false;
    }

    public static List<List<String>> splitAskLLMList(List<String> pendingList, int batchSize) {
        List<List<String>> result = new ArrayList<>();
        for (int i = 0; i < pendingList.size(); i += batchSize) {
            result.add(pendingList.subList(
                    i,
                    Math.min(i + batchSize, pendingList.size())
            ));
        }
        return result;
    }

    public static int getBatchSize(int inputSize) {
        int coreThreads = Runtime.getRuntime().availableProcessors();
        // 动态计算批次大小规则：
        // 1. 每个核心处理1个批次（经验值，可根据实际调整）
        // 2. 最小批次大小为1，最大不超过10（防止单批次过大）
        int factor = 1;
        int batchSize = Math.min(
                Math.max(1, (int) Math.ceil((double) inputSize / (coreThreads * factor))),
                10
        );
        return batchSize;
    }

    public static List<JSONArray> splitAskLLM(JSONArray jsonArray, int batchSize) {
        List<JSONArray> result = new ArrayList<>((jsonArray.size() + batchSize - 1) / batchSize);
        for (int i = 0; i < jsonArray.size(); i += batchSize) {
            int end = Math.min(i + batchSize, jsonArray.size());
            JSONArray subArray = new JSONArray(jsonArray.subList(i, end));
            result.add(subArray);
        }
        return result;
    }

    public static String getResultString(String text) {
        if (text == null || text.isEmpty()) {
            return "";
        }

        int start = text.indexOf("{") + 1; // 跳过 "```json"
        int end = text.indexOf("}", start);    // 找到第一个 ``` 的位置
        if (end <= start) {
            return ""; // 如果未找到有效内容，返回空字符串
        }

        String extractedContent = text.substring(start, end).trim();
        return extractedContent;
    }
}
